home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / viewers / polyview / polyvw20.lha / PolyView2.0 / Examples / example.c < prev    next >
C/C++ Source or Header  |  1991-07-26  |  7KB  |  349 lines
  1. /*
  2. drop.c
  3. NCSA Software Tools Group
  4. March 7, 1991
  5.  
  6. DESCRIPTION
  7. This program creates a sample HDF Vset data file useful for testing
  8. PolyView.  The file is an animation sequence of a set of cubes being dropped
  9. onto a plane from random heights.
  10.  
  11. The created file is named "drop.hdf" and contains the following vgroups and
  12. vdataatasets:
  13.  
  14.     frameXXX    Vgroups containing frames of simulation
  15.  
  16.     px        X dimension data set
  17.     py        Y dimension data set
  18.     pz        Z dimension data set
  19.  
  20.     vz        Y dimension data set
  21.  
  22.     plist4        connectivity list for polygons and quadrilaterals
  23. */
  24.  
  25.  
  26. /* INCLUDES */
  27. #include <stdio.h>
  28. #include <ctype.h>
  29. #include <unistd.h>
  30. #include "df.h"
  31. #include "dfi.h"
  32. #include "vg.h"
  33.  
  34.  
  35. /* DEFINES */
  36. #define POINTS        5000
  37. #define VERTS        5000
  38. #define BLOCKS        5000
  39.  
  40. #define    TIMESTEP    0.01
  41. #define ELASTICITY    0.7
  42.  
  43. #define    CUBE        0.4
  44. #define    HALFCUBE    (CUBE/2)
  45.  
  46. #define FILE        "drop.hdf"
  47.  
  48.  
  49. /* Random number generator information */
  50. #define MAX_RND         (1<<31)
  51. #define RND(min,max)    (double)(((((double)lcm_rnd())/(MAX_RND-1))*\
  52.                             ((double) max - (double) min)) + (double) min)
  53.  
  54.  
  55. /* TYPES */
  56.  
  57.  
  58. /* GLOBAL VARIABLES */
  59. float    bz[BLOCKS];
  60. float    bvz[BLOCKS];
  61.  
  62. float    px[VERTS];
  63. float    py[VERTS];
  64. float    pz[VERTS];
  65.  
  66. float    vz[VERTS];
  67.  
  68. int    plist4[VERTS];
  69.  
  70. /* Size of the grid that blocks are scattered over. */
  71. int    x = 5, y = 5;
  72. int    frames = 100;
  73.  
  74. int    np = 0;
  75. int    nv4 = 0;
  76.  
  77.  
  78. /* PROTOTYPES */
  79. unsigned long lcm_seed;
  80. void lcm_randomize(unsigned long);
  81. unsigned long lcm_rnd();
  82.  
  83. void init_vars();
  84. void gen_data();
  85. void write_to_hdf();
  86.  
  87.  
  88. /* MAIN */
  89. main(argc, argv)
  90.     int argc;
  91.     char * argv[];
  92. {
  93.     /* Initialize global variables */
  94.     init_vars();
  95.  
  96.     /* Write the data to the file */
  97.     write_to_hdf();
  98. }
  99.  
  100.  
  101. /* FUNCTION DECLARATIONS */
  102.  
  103. void
  104. init_vars()
  105. /* DESCRIPTION:  Reinitializes all global variables to prepare for generating
  106. another set of data.
  107. */
  108. {
  109.     int        i, j;
  110.  
  111.  
  112.     /* Initialize vertical positions of each block to a random value. */
  113.     /* Each block's initial velocity is zero. */
  114.     for (i = 0; i < x * y; i++) {
  115.         bz[i] = RND(0.5, 5.0);
  116.         bvz[i] = 0.0;
  117.     }
  118. }
  119.  
  120. void rpp(float, float, float, float, float, float, float);
  121.  
  122. void
  123. gen_data()
  124. /* DESCRIPTION:  Generates the next time step of the "simulation".
  125. */
  126. {
  127.     int        i, j;
  128.  
  129.  
  130.     nv4 = 0;
  131.     np = 0;
  132.  
  133.     /* Build the polygons for each of the cubes. */
  134.     for (i = 0; i < x; i++) {
  135.         for (j = 0; j < y; j++) {
  136.             rpp(i-HALFCUBE,j-HALFCUBE,bz[i*y + j],
  137.                 CUBE,CUBE,CUBE, bvz[i*y + j]);
  138.         }
  139.     }
  140.  
  141.     /* Calculate the *next* timestep.  Update each cube's position, */
  142.     /* then its velocity.  If the position becomes negative, adjust */
  143.     /* accordingly. */
  144.     for (i = 0; i < x*y; i++) {
  145.         /* Update the position */
  146.         bz[i] += bvz[i];
  147. #if 0
  148. printf("v = %f\n", bz[i]);
  149. #endif
  150.  
  151.         /* If the block is below the z = 0 plane, then its position */
  152.         /* should be corrected -- it has "bounced". */
  153.         if (bz[i] <= 0.0) {
  154.             bz[i] = -bz[i] * ELASTICITY;
  155.             bvz[i] = -bvz[i] * ELASTICITY;
  156.         }
  157.  
  158.         /* Update the velocity */
  159.         bvz[i] -= 9.81 * TIMESTEP;
  160.     }
  161. }
  162.  
  163.     int
  164.     add_pt(float x, float y, float z, float v)
  165.     /* DESCRIPTION:  Adds points x, y, and z to the px, py, and pz arrays,
  166.     respectively.  Also adds v to the vz array.  Increments np.
  167.     */
  168.     {
  169.         px[np] = x;
  170.         py[np] = y;
  171.         pz[np] = z;
  172.  
  173.         vz[np] = v;
  174.  
  175.         np++;
  176.  
  177.         return np-1;
  178.     }
  179.  
  180.  
  181.     void
  182.     connect4(p0, p1, p2, p3)
  183.         int p0, p1, p2, p3;
  184.     /* DESCRIPTION:  Connects points p0, p1, p2, p3 in the plist4 array.
  185.     Increments nv4. */
  186.     {
  187.         plist4[nv4*4+0] = p0+1;
  188.         plist4[nv4*4+1] = p1+1;
  189.         plist4[nv4*4+2] = p2+1;
  190.         plist4[nv4*4+3] = p3+1;
  191.  
  192.         nv4++;
  193.     }
  194.  
  195.  
  196.     void
  197.     rpp(float x, float y, float z, float a, float b, float c, float v)
  198.     /* DESCRIPTION:  Adds the vertices for a rectangular parallelpiped 
  199.     with near corner (x, y, z) and far corner (x+a, y+b, z+c) to the
  200.     px, py, and pz arrays, and connects them in plist4.  Also adds a
  201.     v value for each vertex.
  202.     */
  203.     {
  204.         int p[8];
  205.  
  206.         /* Add the points to the array */
  207.         p[0] = add_pt(x, y, z, v);
  208.         p[1] = add_pt(x, y+b, z, v);
  209.         p[2] = add_pt(x+a, y+b, z, v);
  210.         p[3] = add_pt(x+a, y, z, v);
  211.         p[4] = add_pt(x, y, z+c, v);
  212.         p[5] = add_pt(x, y+b, z+c, v);
  213.         p[6] = add_pt(x+a, y+b, z+c, v);
  214.         p[7] = add_pt(x+a, y, z+c, v);
  215.  
  216.         /* Connect the dots */
  217.         connect4(p[0], p[1], p[2], p[3]);
  218.         connect4(p[5], p[6], p[2], p[1]);
  219.         connect4(p[0], p[4], p[5], p[1]);
  220.         connect4(p[0], p[3], p[7], p[4]);
  221.         connect4(p[2], p[6], p[7], p[3]);
  222.         connect4(p[7], p[6], p[5], p[4]);
  223.     }
  224.  
  225.  
  226. void
  227. write_to_hdf()
  228. /* DESCRIPTION:  Writes the data sets to the a new hdf file.
  229. */
  230. {
  231.     DF        * f;
  232.  
  233.     VGROUP        * root;
  234.     VGROUP        * frame;
  235.  
  236.     VDATA        * vpx;
  237.     VDATA        * vpy;
  238.     VDATA        * vpz;
  239.     VDATA        * vvz;
  240.     VDATA        * vplist4;
  241.  
  242.     char        name[80];
  243.     int        n;
  244.  
  245.  
  246.  
  247.     /* Remove the file, if it already exists. */
  248.     unlink("drop.hdf");
  249.  
  250.  
  251.     /* Create the HDF file */
  252.     f = DFopen("drop.hdf", DFACC_ALL, 0);
  253.  
  254.  
  255.     /* Create the root and insert its children */
  256.     root = (VGROUP *) Vattach(f, -1, "w");
  257.     Vsetname(root, "/");
  258.  
  259.     /* Create frames under the root group.  Insert all of the */
  260.     /* data sets in there. */
  261.     for (n = 1; n <= frames; n++) {
  262.  
  263.         /* Generate the next time step of data for the file */
  264.         gen_data();
  265.  
  266.         /* Create the vdatas for the frames of the animation */
  267.         vpx = (VDATA *) VSattach(f, -1, "w");
  268.         VSsetname(vpx, "px");
  269.         VSsetfields(vpx, "px");
  270.         VSwrite(vpx, px, np, NO_INTERLACE);
  271.  
  272.         vpy = (VDATA *) VSattach(f, -1, "w");
  273.         VSsetname(vpy, "py");
  274.         VSsetfields(vpy, "py");
  275.         VSwrite(vpy, py, np, NO_INTERLACE);
  276.  
  277.         vpz = (VDATA *) VSattach(f, -1, "w");
  278.         VSsetname(vpz, "pz");
  279.         VSsetfields(vpz, "pz");
  280.         VSwrite(vpz, pz, np, NO_INTERLACE);
  281.  
  282.         /* Create velocity dataset. */
  283.         /* Define a new data type for the vset file. */
  284.         vvz = (VDATA *) VSattach(f, -1, "w");
  285.         if (VSfdefine(vvz, "vz", LOCAL_FLOATTYPE, 1) == -1)
  286.             printf("ERROR:  Problem defining 'vz'.\n");
  287.         VSsetname(vvz, "vz");
  288.         VSsetfields(vvz, "vz");
  289.         VSwrite(vvz, vz, np, NO_INTERLACE);
  290.  
  291.         if (n == 1) {
  292.             /* Create connectivity dataset and insert it */
  293.             vplist4 = (VDATA *) VSattach(f, -1, "w");
  294.             VSfdefine(vplist4, "plist4", LOCAL_INTTYPE, 4);
  295.             VSsetname(vplist4, "plist4");
  296.             VSsetfields(vplist4, "plist4");
  297.             VSwrite(vplist4, plist4, nv4, NO_INTERLACE);
  298.         }
  299.  
  300.         sprintf(name, "frame%02d", n);
  301.         frame = (VGROUP *) Vattach(f, -1, "w");
  302.         Vsetname(frame, name);
  303.         Vinsert(root, frame);
  304.  
  305.         /* Insert the vdatas under the current frame */
  306.         Vinsert(frame, vpx);
  307.         Vinsert(frame, vpy);
  308.         Vinsert(frame, vpz);
  309.         Vinsert(frame, vvz);
  310.         if (n == 1) {
  311.             Vinsert(frame, vplist4);
  312.         }
  313.  
  314.         VSdetach(vpx);
  315.         VSdetach(vpy);
  316.         VSdetach(vpz);
  317.         VSdetach(vvz);
  318.         if (n == 1) {
  319.             VSdetach(vplist4);
  320.         }
  321.  
  322.         Vdetach(frame);
  323.     }
  324.  
  325.     /* Close down the root group, now that we're done with it */
  326.     Vdetach(root);
  327.  
  328.     DFclose(f);
  329. }
  330.  
  331.  
  332. /* RANDOM NUMBER GENERATOR FUNCTIONS */
  333.  
  334. void lcm_randomize(seed)
  335.         unsigned long seed;
  336. {
  337.         lcm_seed = seed;
  338. }
  339.  
  340.  
  341. unsigned long lcm_rnd()
  342. {
  343.         unsigned long rnd_val;
  344.  
  345.         rnd_val = lcm_seed;
  346.         lcm_seed = ((314159269 * lcm_seed) + 453806245) % MAX_RND;
  347.         return (rnd_val);
  348. }
  349.